#include "defines.h"
#include "cgui.h"
#include "cmenu.h"

//sonido
#include <audiere.h> 
using namespace audiere;
#pragma comment (lib, "../../lib/audiere.lib")


#define MAXMODEL	50
#define MAXTEXTURE  50
#define SOUNDS 15
#define SONGS 15

#ifndef _RESOURCEMANAGER_H
#define _RESOURCEMANAGER_H
class ResourceManager
{
public:

	static video::ITexture* tNumbers;

	static void ParseNumber(int n, core::position2d<s32> s);
	static void DrawNumbers(int n, core::position2d<s32> s);
	static cGUI Gui;
	static cMenu Menu;
	static void InitGui();
	static bool InitMenu();
	static void DrawEnv();
	static void ShowGame();

	static void StartAudio();
	static void PlaySound(int sound,float volume);
	static void PlaySound(int sound);
	static void PlayMusic(int song,float volume);
	static void PlayMusic(int song);

	static AudioDevicePtr audiereDevice;
	static OutputStreamPtr sound;
	static OutputStreamPtr sSound[SOUNDS];
	static OutputStreamPtr sSong[SONGS];

//	static char **sModel;
//	static char **sTexture;	
//	static char **sModelLoaded; //modelos cargados 
//	static scene::IAnimatedMeshSceneNode* mModels;
//	static int	nModelIndex;//cantidad actual de modelos cargados

	struct Modelo 
	{
		scene::IAnimatedMeshSceneNode* mModel;
		char sModel[50];
		video::ITexture* tTexture;
	};

	static Modelo Models[MAXMODEL];
	static int iLastModel;
	static scene::IAnimatedMeshSceneNode* mModelLoaded;

	enum SOUND
	{
		Ball = 0,
		Impact = 1
	};

	enum MUSIC
	{
		ColdPlay = 0
	};	

	enum MODEL
	{
		Sydney = 1,
		Faerie = 2
	};

	enum TEXTURE
	{
		SydneyBlack = 1,
		FaerieGreen = 2,
		FaerieDark = 3
	};
	
	static scene::ITriangleSelector* selector;

	static video::IVideoDriver*		driver;
	static scene::ISceneManager*	smgr;

//	vector<int> loadedTexture;

	//devuelve si ya esta cargado el mesh
	static bool IsModelLoaded(int modelIndex);

	//devuelve una textura
	static video::ITexture* LoadTexture(const c8* filename);

	//le pone una textura a un nodo/entidad
	static bool SetTextureNode(scene::ISceneNode* node,const c8* filename);

	//le da forma de cubo a un nodo/entidad
	static bool SetCubeForm(scene::ISceneNode* node);

	//desabilita la luz a un nodo
	static void DisableLighting(scene::ISceneNode* node)
	{
		node->setMaterialFlag(video::EMF_LIGHTING, false);
	}

	//habilita la luz un nodo
	static void EnableLighting(scene::ISceneNode* node)
	{
		node->setMaterialFlag(video::EMF_LIGHTING, false);
	}

	//dibujo
	static void Draw()
	{
		smgr->drawAll();
	}

	//devuelve un nodo con forma de cubo
	static scene::ISceneNode* GetCubeNode()
	{
		return smgr->addCubeSceneNode();
	}

	//devuelve un nodo con forma de esfera
	static scene::ISceneNode* GetSphereNode()
	{
		return smgr->addSphereSceneNode();
	}

	//Carga un Modelo Animado
	static scene::IAnimatedMeshSceneNode* LoadAnimatedModel(const c8* filename);

	//cargo un 3ds
	static void Load3dsModel(const c8* filename,const c8* texturename);

	//Creacion de una entidad 3D x strings
	static scene::IAnimatedMeshSceneNode* CreateEntity(const c8* meshFile,const c8* textureFile);

	//Creacion de una entidad 3D x indices
	static scene::IAnimatedMeshSceneNode* CreateEntity(int meshIndex);

	//Creacion de un cubo
	static void CreateCube(const c8* textureFile);

	//Le pone una animacion a un modelo
	static void SetStraightAnimator(scene::ISceneNode* node);
	
	//pone la camara como FPS
	static void SetFPSCamera()
	{
		smgr->addCameraSceneNodeFPS(0, 100.0f, 100.0f);
		Global::device->getCursorControl()->setVisible(false);
	}

	static void init (void)
	{
		StartAudio();
		iLastModel = 0;

		tNumbers = Global::driver->getTexture("../media/num.png");
		driver = Global::device->getVideoDriver();
		smgr = Global::device->getSceneManager();
	}

	static void LoadMap();
	
	ResourceManager();
	~ResourceManager();
};

#endif // _RESOURCEMANAGER_H